home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 14 / CU Amiga Magazine's Super CD-ROM 14 (1997)(EMAP Images)(GB)(Track 1 of 3)[!][issue 1997-09].iso / CUCD / Programming / IEditor / prefs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-06-17  |  34.5 KB  |  1,789 lines
  1. /// Include
  2. #define INTUI_V36_NAMES_ONLY
  3. #define ASL_V38_NAMES_ONLY
  4. #define CATCOMP_NUMBERS
  5.  
  6. #include <exec/memory.h>                // exec
  7. #include <exec/execbase.h>
  8. #include <intuition/intuition.h>        // intuition
  9. #include <libraries/gadtools.h>         // libraries
  10. #include <libraries/asl.h>
  11. #include <clib/exec_protos.h>           // protos
  12. #include <clib/intuition_protos.h>
  13. #include <clib/dos_protos.h>
  14. #include <clib/asl_protos.h>
  15. #include <clib/locale_protos.h>
  16. #include <clib/gadtools_protos.h>
  17. #include <clib/reqtools_protos.h>
  18. #include <pragmas/exec_pragmas.h>       // pragmas
  19. #include <pragmas/intuition_pragmas.h>
  20. #include <pragmas/dos_pragmas.h>
  21. #include <pragmas/locale_pragmas.h>
  22. #include <pragmas/asl_pragmas.h>
  23. #include <pragmas/gadtools_pragmas.h>
  24. #include <pragmas/reqtools_pragmas.h>
  25.  
  26. #include <stdarg.h>
  27. #include <string.h>
  28. #include <stdio.h>
  29. #include <stdlib.h>
  30.  
  31. #include "DEV_IE:defs.h"
  32. #include "DEV_IE:GUI.h"
  33. #include "DEV_IE:GUI_locale.h"
  34. #include "DEV_IE:Include/generatorlib-protos.h"
  35. #include "DEV_IE:Include/generator_pragmas.h"
  36. ///
  37. /// Prototipi
  38. static void     AttaccaLibsList( void );
  39. static void     AttaccaWndsList( void );
  40. static void     StaccaLibsList( void );
  41. static void     StaccaWndsList( void );
  42. static void     AttivaLibsGads( void );
  43. static void     AttivaWndsGads( void );
  44. static void     DisattivaLibsGads( void );
  45. static void     DisattivaWndsGads( void );
  46. static void     SistemaLibsGads( struct LibNode * );
  47. static BOOL     MP_EditLib( struct LibNode * );
  48. static void     AttaccaRexxList( void );
  49. static void     StaccaRexxList( void );
  50. static BOOL     EditRexxCmd( struct RexxNode * );
  51. static void     SistemaF( void );
  52. static void     rx_GetFile( UWORD );
  53. static void     RemakeMacroMenu( void );
  54. static BOOL     ExecMenuMacro( void );
  55. static struct Menu *GetMacroMenu( void );
  56. static void     HandleGen( void );
  57. static void     HandleMacro( void );
  58. static void     HandleMainProc( void );
  59. static void     HandleRexxEd( void );
  60. ///
  61. /// Dati
  62. static struct LibNode  *MP_BackLib;
  63. static WORD             MP_RetCode;
  64.  
  65. static UWORD    MP_Timer, MP_buf, MP_buf2;
  66. static ULONG    MP_ListTag[]  = { GTLV_Top, 0, GTLV_Selected, 0, TAG_END };
  67. static ULONG    MP_ListTag2[] = { GTLV_Top, 0, GTLV_Selected, 0, TAG_END };
  68.  
  69. static ULONG    RE_ListTag[]  = { GTLV_Top, 0, GTLV_Selected, 0, TAG_END };
  70. static UWORD    RE_Timer, RE_Last;
  71.  
  72. UWORD           NewRexxID;
  73.  
  74. UWORD           F_Offset;
  75.  
  76. TEXT            ExtraProc[60];
  77. TEXT            RexxExt[15];
  78. TEXT            ARexxPortName[50];
  79.  
  80. struct MinList MacroList = { &MacroList.mlh_Tail, NULL, &MacroList.mlh_Head };
  81. UWORD           NumMacros;
  82.  
  83. WORD            Timer;
  84.  
  85. static TEXT     ReqFile[30];
  86. static TEXT     ReqDrawer[256];
  87.  
  88. static STRPTR   LibBases[] = {
  89.         "ArpBase",
  90.         "AslBase",
  91.         "CommoditiesBase",
  92.         AP_FntString2,
  93.         "ExpansionBase",
  94.         AP_GadString2,
  95.         AP_GfxString2,
  96.         "IconBase",
  97.         "IFFParseBase",
  98.         AP_IntString2,
  99.         "KeymapBase",
  100.         "LayersBase",
  101.         "MathBase",
  102.         "MathIeeeDoubBasBase",
  103.         "MathIeeeDoubTransBase",
  104.         "MathIeeeSingBasBase",
  105.         "MathIeeeSingTransBase",
  106.         AP_RexxString2,
  107.         "ReqToolsBase",
  108.         "TranslatorBase",
  109.         "UtilityBase",
  110.         "WorkbenchBase",
  111.         "LocaleBase",
  112.         "BulletBase",
  113.         "DataTypesBase",
  114.         "XPKMasterBase",
  115.         AP_DosString2
  116.     };
  117.  
  118. static UWORD MacroGads[] = {
  119.         GD_rx_1,
  120.         GD_rx_2,
  121.         GD_rx_3,
  122.         GD_rx_4,
  123.         GD_rx_5,
  124.         GD_rx_6,
  125.         GD_rx_7,
  126.         GD_rx_8,
  127.         GD_rx_9,
  128.         GD_rx_10,
  129.     };
  130.  
  131. UBYTE   AsmPrefs, AsmPrefs2, C_Prefs;
  132.  
  133. TEXT    AP_IntString2[60]  = "IntuitionBase";
  134. TEXT    AP_DosString2[60]  = "DOSBase";
  135. TEXT    AP_GfxString2[60]  = "GfxBase";
  136. TEXT    AP_GadString2[60]  = "GadToolsBase";
  137. TEXT    AP_RexxString2[60] = "RexxSysBase";
  138. TEXT    AP_FntString2[60]  = "DiskfontBase";
  139.  
  140. TEXT    CP_ChipString2[25] = "UWORD __chip";
  141. ///
  142.  
  143.  
  144. //      Main Proc Editor
  145. /// Elimina Main Proc Data
  146. void EliminaMainProcData( void )
  147. {
  148.     struct LibNode     *lib;
  149.     struct WndToOpen   *wto;
  150.  
  151.     IE.NumLibs = IE.NumWndTO = 0;
  152.  
  153.     while( lib = RemTail((struct List *)&IE.Libs_List ))
  154.     FreeObject( lib, IE_LIBRARY );
  155.  
  156.     while( wto = RemTail((struct List *)&IE.WndTO_List ))
  157.     FreeObject( wto, IE_WNDTOOPEN );
  158. }
  159. ///
  160. /// Main Proc Editor
  161. BOOL MainProcMenued( void )
  162. {
  163.     int     ret;
  164.  
  165.     if( MainProcWnd ) {
  166.     ActivateWindow( MainProcWnd );
  167.     WindowToFront( MainProcWnd );
  168.     return( TRUE );
  169.     }
  170.  
  171.     LayoutWindow( MainProcWTags );
  172.     ret = OpenMainProcWindow();
  173.     PostOpenWindow( MainProcWTags );
  174.  
  175.     if( ret ) {
  176.     DisplayBeep( Scr );
  177.     CloseMainProcWindow();
  178.     } else {
  179.  
  180.     if( GadToolsBase->lib_Version >= 39 ) {
  181.         MP_ListTag[0]  = GTLV_MakeVisible;
  182.         MP_ListTag2[0] = GTLV_MakeVisible;
  183.     }
  184.  
  185.     MP_ListTag[1] = MP_ListTag[3] = MP_ListTag2[1] = MP_ListTag2[3] = 0;
  186.  
  187.     AttaccaLibsList();
  188.     AttaccaWndsList();
  189.  
  190.     if( IE.NumLibs )
  191.         AttivaLibsGads();
  192.  
  193.     if( IE.NumWndTO )
  194.         AttivaWndsGads();
  195.  
  196.     CheckedTag[1] = ( IE.MainProcFlags & MAIN_CTRL_C ) ? TRUE : FALSE;
  197.     GT_SetGadgetAttrsA( MainProcGadgets[ GD_MP_CtrlC ], MainProcWnd,
  198.                 NULL, (struct TagItem *)CheckedTag );
  199.  
  200.     CheckedTag[1] = ( IE.MainProcFlags & MAIN_OTHERBITS ) ? TRUE : FALSE;
  201.     GT_SetGadgetAttrsA( MainProcGadgets[ GD_MP_XtraBits ], MainProcWnd,
  202.                 NULL, (struct TagItem *)CheckedTag );
  203.  
  204.     CheckedTag[1] = ( IE.MainProcFlags & MAIN_WB ) ? TRUE : FALSE;
  205.     GT_SetGadgetAttrsA( MainProcGadgets[ GD_MP_WB ], MainProcWnd,
  206.                 NULL, (struct TagItem *)CheckedTag );
  207.  
  208.     StringTag[1] = ExtraProc;
  209.     GT_SetGadgetAttrsA( MainProcGadgets[ GD_MP_XtraProc ], MainProcWnd,
  210.                 NULL, (struct TagItem *)StringTag );
  211.  
  212.     MP_Timer = 0;
  213.  
  214.     MP_buf = MP_buf2 = -1;
  215.  
  216.     MainProcWnd->ExtData = HandleMainProc;
  217.     }
  218.  
  219.     return( TRUE );
  220. }
  221.  
  222. void HandleMainProc( void )
  223. {
  224.     if(!( HandleMainProcIDCMP() ))
  225.     CloseMainProcWindow();
  226. }
  227.  
  228. void StaccaLibsList( void )
  229. {
  230.     ListTag[1] = NULL;
  231.     GT_SetGadgetAttrsA( MainProcGadgets[ GD_MP_OpenLib ], MainProcWnd,
  232.             NULL, (struct TagItem *)ListTag );
  233. }
  234.  
  235. void StaccaWndsList( void )
  236. {
  237.     ListTag[1] = NULL;
  238.     GT_SetGadgetAttrsA( MainProcGadgets[ GD_MP_OpenWnd ], MainProcWnd,
  239.             NULL, (struct TagItem *)ListTag );
  240. }
  241.  
  242. void AttaccaLibsList( void )
  243. {
  244.     ListTag[1] = &IE.Libs_List;
  245.     GT_SetGadgetAttrsA( MainProcGadgets[ GD_MP_OpenLib ], MainProcWnd,
  246.             NULL, (struct TagItem *)ListTag );
  247.     GT_SetGadgetAttrsA( MainProcGadgets[ GD_MP_OpenLib ], MainProcWnd,
  248.             NULL, (struct TagItem *)MP_ListTag );
  249. }
  250.  
  251. void AttaccaWndsList( void )
  252. {
  253.     ListTag[1] = &IE.WndTO_List;
  254.     GT_SetGadgetAttrsA( MainProcGadgets[ GD_MP_OpenWnd ], MainProcWnd,
  255.             NULL, (struct TagItem *)ListTag );
  256.     GT_SetGadgetAttrsA( MainProcGadgets[ GD_MP_OpenWnd ], MainProcWnd,
  257.             NULL, (struct TagItem *)MP_ListTag2 );
  258. }
  259.  
  260. BOOL MP_OpenLibClicked( void )
  261. {
  262.     UWORD           old = MP_buf;
  263.     struct LibNode *lib;
  264.  
  265.     MP_buf = MP_ListTag[1] = MP_ListTag[3] = IDCMPMsg.Code;
  266.  
  267.     AttivaLibsGads();
  268.  
  269.     if( MP_Timer < 3 ) {
  270.     if( old == MP_buf ) {
  271.         lib = (struct Node *)&IE.Libs_List;
  272.         for( old = 0; old <= MP_buf; old++ )
  273.         lib = lib->lbn_Node.ln_Succ;
  274.  
  275.         MP_EditLib( lib );
  276.     }
  277.     }
  278.  
  279.     MP_Timer = 0;
  280.  
  281.     return( TRUE );
  282. }
  283.  
  284. void AttivaLibsGads( void )
  285. {
  286.     DisableTag[1] = FALSE;
  287.     GT_SetGadgetAttrsA( MainProcGadgets[ GD_MP_DelLib ], MainProcWnd,
  288.             NULL, (struct TagItem *)DisableTag );
  289. }
  290.  
  291. void DisattivaLibsGads( void )
  292. {
  293.     DisableTag[1] = TRUE;
  294.     GT_SetGadgetAttrsA( MainProcGadgets[ GD_MP_DelLib ], MainProcWnd,
  295.             NULL, (struct TagItem *)DisableTag );
  296. }
  297.  
  298. void AttivaWndsGads( void )
  299. {
  300.     struct Gadget  *g;
  301.     int             pos, cnt;
  302.  
  303.     DisableTag[1] = FALSE;
  304.     GT_SetGadgetAttrsA( MainProcGadgets[ GD_MP_DelWnd ], MainProcWnd,
  305.             NULL, (struct TagItem *)DisableTag );
  306.  
  307.     g  = &MP_WndUpGadget;
  308.  
  309.     pos = RemoveGList( MainProcWnd, g, 4 );
  310.  
  311.     for( cnt = 0; cnt < 4; cnt++ ) {
  312.     g->Flags &= ~GFLG_DISABLED;
  313.     g = g->NextGadget;
  314.     }
  315.  
  316.     AddGList( MainProcWnd, &MP_WndUpGadget, pos, 4, NULL );
  317.  
  318.     RefreshGList( &MP_WndUpGadget, MainProcWnd, NULL, 4 );
  319. }
  320.  
  321. void DisattivaWndsGads( void )
  322. {
  323.     struct Gadget  *g;
  324.     int             pos, cnt;
  325.  
  326.     DisableTag[1] = TRUE;
  327.     GT_SetGadgetAttrsA( MainProcGadgets[ GD_MP_DelWnd ], MainProcWnd,
  328.             NULL, (struct TagItem *)DisableTag );
  329.  
  330.     g  = &MP_WndUpGadget;
  331.  
  332.     pos = RemoveGList( MainProcWnd, g, 4 );
  333.  
  334.     for( cnt = 0; cnt < 4; cnt++ ) {
  335.     g->Flags |= GFLG_DISABLED;
  336.     g = g->NextGadget;
  337.     }
  338.  
  339.     AddGList( MainProcWnd, &MP_WndUpGadget, pos, 4, NULL );
  340.  
  341.     RefreshGList( &MP_WndUpGadget, MainProcWnd, NULL, 4 );
  342. }
  343.  
  344. BOOL MP_LibFromClicked( void )
  345. {
  346.     UWORD           old = MP_buf2;
  347.     struct LibNode *lib;
  348.     struct Node    *lib2;
  349.  
  350.     MP_buf2 = IDCMPMsg.Code;
  351.  
  352.     if( MP_Timer < 3 ) {
  353.     if( old == MP_buf2 ) {
  354.  
  355.         if( lib = AllocObject( IE_LIBRARY )) {
  356.  
  357.         lib2 = (struct Node *)&MP_LibFromList;
  358.         for( old = 0; old <= MP_buf2; old++ )
  359.             lib2 = lib2->ln_Succ;
  360.  
  361.         lib->lbn_Node.ln_Pri |= L_FAIL;
  362.  
  363.         strcpy( lib->lbn_Name, lib2->ln_Name );
  364.         strcpy( lib->lbn_Base, LibBases[ MP_buf2 ]);
  365.  
  366.         struct LibNode *lb;
  367.         for( lb = IE.Libs_List.mlh_Head; lb->lbn_Node.ln_Succ; lb = lb->lbn_Node.ln_Succ )
  368.             if(!( strcmp( lib->lbn_Name, lb->lbn_Name ))) {
  369.             FreeObject( lib, IE_LIBRARY );
  370.             return( TRUE );
  371.             }
  372.  
  373.         StaccaLibsList();
  374.         AddTail((struct List *)&IE.Libs_List, (struct Node *)lib );
  375.         AttaccaLibsList();
  376.  
  377.         IE.NumLibs += 1;
  378.  
  379.         IE.flags &= ~SALVATO;
  380.  
  381.         } else {
  382.         Stat( CatCompArray[ ERR_NOMEMORY ].cca_Str, TRUE, 0 );
  383.         }
  384.  
  385.     }
  386.     }
  387.  
  388.     MP_Timer = 0;
  389.  
  390.     return( TRUE );
  391. }
  392.  
  393. BOOL MP_DelLibClicked( void )
  394. {
  395.     struct LibNode *lib;
  396.     int             cnt;
  397.  
  398.     lib = (struct LibNode *)&IE.Libs_List;
  399.     for( cnt = 0; cnt <= MP_ListTag[1]; cnt++ )
  400.     lib = lib->lbn_Node.ln_Succ;
  401.  
  402.     StaccaLibsList();
  403.     Remove((struct Node *)lib );
  404.     AttaccaLibsList();
  405.  
  406.     FreeObject( lib, IE_LIBRARY );
  407.  
  408.     IE.NumLibs -= 1;
  409.  
  410.     IE.flags &= ~SALVATO;
  411.  
  412.     DisattivaLibsGads();
  413.  
  414.     return( TRUE );
  415. }
  416.  
  417. BOOL MP_AddLibClicked( void )
  418. {
  419.     struct LibNode *lib;
  420.  
  421.     if( lib = AllocObject( IE_LIBRARY )) {
  422.  
  423.     lib->lbn_Node.ln_Pri |= L_FAIL;
  424.  
  425.     if( MP_EditLib( lib )) {
  426.  
  427.         lib->lbn_Node.ln_Name = lib->lbn_Name;
  428.  
  429.         struct LibNode *lb;
  430.         for( lb = IE.Libs_List.mlh_Head; lb->lbn_Node.ln_Succ; lb = lb->lbn_Node.ln_Succ )
  431.         if(!( strcmp( lib->lbn_Name, lb->lbn_Name ))) {
  432.             FreeObject( lib, IE_LIBRARY );
  433.             return( TRUE );
  434.         }
  435.  
  436.         StaccaLibsList();
  437.         AddTail((struct List *)&IE.Libs_List, (struct Node *)lib );
  438.         AttaccaLibsList();
  439.  
  440.         IE.NumLibs += 1;
  441.  
  442.         IE.flags &= ~SALVATO;
  443.  
  444.     } else {
  445.         FreeObject( lib, IE_LIBRARY );
  446.         Stat( CatCompArray[ MSG_ABORTED ].cca_Str, FALSE, 0 );
  447.     }
  448.  
  449.     } else
  450.     Stat( CatCompArray[ ERR_NOMEMORY ].cca_Str, TRUE, 0 );
  451.  
  452.     return( TRUE );
  453. }
  454.  
  455. BOOL MP_OpenWndClicked( void )
  456. {
  457.     MP_ListTag2[1] = MP_ListTag2[3] = IDCMPMsg.Code;
  458.     AttivaWndsGads();
  459.     return( TRUE );
  460. }
  461.  
  462. BOOL MP_AddWndClicked( void )
  463. {
  464.     struct WindowInfo  *wnd;
  465.     struct WndToOpen   *wto;
  466.     APTR                Lock;
  467.  
  468.     Lock = rtLockWindow( MainProcWnd );
  469.  
  470.     if( wnd = GetWnd() ) {
  471.  
  472.     for( wto = IE.WndTO_List.mlh_Head; wto->wto_Node.ln_Succ; wto = wto->wto_Node.ln_Succ )
  473.         if(!( strcmp( wnd->wi_Label, wto->wto_Label ))) {
  474.         rtUnlockWindow( MainProcWnd, Lock );
  475.         return( TRUE );
  476.         }
  477.  
  478.     if( wto = AllocObject( IE_WNDTOOPEN )) {
  479.  
  480.         strcpy( wto->wto_Label, wnd->wi_Label );
  481.  
  482.         StaccaWndsList();
  483.         AddTail((struct List *)&IE.WndTO_List, (struct Node *)wto );
  484.         AttaccaWndsList();
  485.  
  486.         IE.NumWndTO += 1;
  487.  
  488.         IE.flags &= ~SALVATO;
  489.  
  490.         AttivaWndsGads();
  491.  
  492.     } else
  493.         Stat( CatCompArray[ ERR_NOMEMORY ].cca_Str, TRUE, 0 );
  494.  
  495.     } else
  496.     Stat( CatCompArray[ MSG_ABORTED ].cca_Str, FALSE, 0 );
  497.  
  498.     rtUnlockWindow( MainProcWnd, Lock );
  499.  
  500.     return( TRUE );
  501. }
  502.  
  503. BOOL MP_DelWndClicked( void )
  504. {
  505.     struct WndToOpen   *wto;
  506.     int                 cnt;
  507.  
  508.     wto = (struct WndToOpen *)&IE.WndTO_List;
  509.     for( cnt = 0; cnt <= MP_ListTag2[1]; cnt++ )
  510.     wto = wto->wto_Node.ln_Succ;
  511.  
  512.     StaccaWndsList();
  513.     Remove((struct Node *)wto );
  514.     AttaccaWndsList();
  515.  
  516.     FreeObject( wto, IE_WNDTOOPEN );
  517.  
  518.     IE.NumWndTO -= 1;
  519.  
  520.     IE.flags &= ~SALVATO;
  521.  
  522.     DisattivaWndsGads();
  523.  
  524.     return( TRUE );
  525. }
  526.  
  527. BOOL MP_WndTopClicked( void )
  528. {
  529.     struct WndToOpen   *wto;
  530.     int                 cnt;
  531.  
  532.     wto = (struct WndToOpen *)&IE.WndTO_List;
  533.     for( cnt = 0; cnt <= MP_ListTag2[1]; cnt++ )
  534.     wto = wto->wto_Node.ln_Succ;
  535.  
  536.     StaccaWndsList();
  537.  
  538.     Remove((struct Node *)wto );
  539.     AddHead((struct List *)&IE.WndTO_List, (struct Node *)wto );
  540.  
  541.     MP_ListTag2[1] = MP_ListTag2[3] = 0;
  542.  
  543.     AttaccaWndsList();
  544.  
  545.     IE.flags &= ~SALVATO;
  546.  
  547.     return( TRUE );
  548. }
  549.  
  550. BOOL MP_WndBottomClicked( void )
  551. {
  552.     struct WndToOpen   *wto;
  553.     int                 cnt;
  554.  
  555.     wto = (struct WndToOpen *)&IE.WndTO_List;
  556.     for( cnt = 0; cnt <= MP_ListTag2[1]; cnt++ )
  557.     wto = wto->wto_Node.ln_Succ;
  558.  
  559.     StaccaWndsList();
  560.  
  561.     Remove((struct Node *)wto );
  562.     AddTail((struct List *)&IE.WndTO_List, (struct Node *)wto );
  563.  
  564.     MP_ListTag2[1] = MP_ListTag2[3] = IE.NumWndTO - 1;
  565.  
  566.     AttaccaWndsList();
  567.  
  568.     IE.flags &= ~SALVATO;
  569.  
  570.     return( TRUE );
  571. }
  572.  
  573. BOOL MP_WndUpClicked( void )
  574. {
  575.     struct WndToOpen   *wto;
  576.     int                 cnt;
  577.  
  578.     if( MP_ListTag2[1] ) {
  579.  
  580.     wto = (struct WndToOpen *)&IE.WndTO_List;
  581.     for( cnt = 0; cnt <= MP_ListTag2[1]; cnt++ )
  582.         wto = wto->wto_Node.ln_Succ;
  583.  
  584.     StaccaWndsList();
  585.  
  586.     NodeUp( wto );
  587.  
  588.     MP_ListTag2[1] -= 1;
  589.     MP_ListTag2[3] -= 1;
  590.  
  591.     AttaccaWndsList();
  592.  
  593.     IE.flags &= ~SALVATO;
  594.  
  595.     }
  596.  
  597.     return( TRUE );
  598. }
  599.  
  600. BOOL MP_WndDownClicked( void )
  601. {
  602.     struct WndToOpen   *wto;
  603.     int                 cnt;
  604.  
  605.     if( MP_ListTag2[1] < IE.NumWndTO - 1 ) {
  606.  
  607.     wto = (struct WndToOpen *)&IE.WndTO_List;
  608.     for( cnt = 0; cnt <= MP_ListTag2[1]; cnt++ )
  609.         wto = wto->wto_Node.ln_Succ;
  610.  
  611.     StaccaWndsList();
  612.  
  613.     NodeDown( wto );
  614.  
  615.     MP_ListTag2[1] += 1;
  616.     MP_ListTag2[3] += 1;
  617.  
  618.     AttaccaWndsList();
  619.  
  620.     IE.flags &= ~SALVATO;
  621.  
  622.     }
  623.  
  624.     return( TRUE );
  625. }
  626.  
  627. BOOL MP_CtrlCClicked( void )
  628. {
  629.     IE.MainProcFlags ^= MAIN_CTRL_C;
  630.     IE.flags &= ~SALVATO;
  631.     return( TRUE );
  632. }
  633.  
  634. BOOL MP_XtraBitsClicked( void )
  635. {
  636.     IE.MainProcFlags ^= MAIN_OTHERBITS;
  637.     IE.flags &= ~SALVATO;
  638.     return( TRUE );
  639. }
  640.  
  641. BOOL MP_WBClicked( void )
  642. {
  643.     IE.MainProcFlags ^= MAIN_WB;
  644.     IE.flags &= ~SALVATO;
  645.     return( TRUE );
  646. }
  647.  
  648. BOOL MP_XtraProcClicked( void )
  649. {
  650.     return( TRUE );
  651. }
  652.  
  653. BOOL MainProcCloseWindow( void )
  654. {
  655.     strcpy( ExtraProc, GetString( MainProcGadgets[ GD_MP_XtraProc ]));
  656.     return( FALSE );
  657. }
  658.  
  659. BOOL MainProcIntuiTicks( void )
  660. {
  661.     MP_Timer += 1;
  662.     return( TRUE );
  663. }
  664. ///
  665. /// EditLib
  666. BOOL MP_EditLib( struct LibNode *lib )
  667. {
  668.     int     ret;
  669.     APTR    MP_Lock;
  670.     BYTE    MP_BackPri;
  671.  
  672.     LockAllWindows();
  673.     MP_Lock = rtLockWindow( MainProcWnd );
  674.  
  675.     LayoutWindow( MPEdLibWTags );
  676.     ret = OpenMPEdLibWindow();
  677.     PostOpenWindow( MPEdLibWTags );
  678.  
  679.     if( ret )
  680.     DisplayBeep( Scr );
  681.     else {
  682.  
  683.     SistemaLibsGads( lib );
  684.  
  685.     MP_BackPri = lib->lbn_Node.ln_Pri;
  686.     MP_BackLib = lib;
  687.  
  688.     MP_RetCode = 0;
  689.  
  690.     do {
  691.         ReqHandle( MPEdLibWnd, HandleMPEdLibIDCMP );
  692.     } while(!( MP_RetCode ));
  693.  
  694.     if( MP_RetCode > 0 ) {
  695.         MP_BackLib->lbn_Node.ln_Pri = MP_BackPri;
  696.         ret = FALSE;
  697.     } else {
  698.  
  699.         StaccaLibsList();
  700.         strcpy( lib->lbn_Name, GetString( MPEdLibGadgets[ GD_MPEL_Lib ]) );
  701.         AttaccaLibsList();
  702.  
  703.         strcpy( lib->lbn_Base, GetString( MPEdLibGadgets[ GD_MPEL_Base ]) );
  704.  
  705.         lib->lbn_Version = GetNumber( MPEdLibGadgets[ GD_MPEL_Vers ]);
  706.  
  707.         IE.flags &= ~SALVATO;
  708.  
  709.         ret = TRUE;
  710.     }
  711.     }
  712.  
  713.     CloseMPEdLibWindow();
  714.  
  715.     rtUnlockWindow( MainProcWnd, MP_Lock );
  716.     UnlockAllWindows();
  717.  
  718.     return( ret );
  719. }
  720.  
  721. void SistemaLibsGads( struct LibNode *lib )
  722. {
  723.     StringTag[1] = lib->lbn_Node.ln_Name;
  724.     GT_SetGadgetAttrsA( MPEdLibGadgets[ GD_MPEL_Lib ], MPEdLibWnd,
  725.             NULL, (struct TagItem *)StringTag );
  726.  
  727.     StringTag[1] = lib->lbn_Base;
  728.     GT_SetGadgetAttrsA( MPEdLibGadgets[ GD_MPEL_Base ], MPEdLibWnd,
  729.             NULL, (struct TagItem *)StringTag );
  730.  
  731.     IntegerTag[1] = lib->lbn_Version;
  732.     GT_SetGadgetAttrsA( MPEdLibGadgets[ GD_MPEL_Vers ], MPEdLibWnd,
  733.             NULL, (struct TagItem *)IntegerTag );
  734.  
  735.     CheckedTag[1] = ( lib->lbn_Node.ln_Pri & L_FAIL ) ? TRUE : FALSE;
  736.     GT_SetGadgetAttrsA( MPEdLibGadgets[ GD_MPEL_Fail ], MPEdLibWnd,
  737.             NULL, (struct TagItem *)CheckedTag );
  738. }
  739.  
  740. BOOL MPEdLibVanillaKey( void )
  741. {
  742.     switch( MPEdLibMsg.Code ) {
  743.     case 13:
  744.         MP_RetCode = -1;
  745.         break;
  746.     case 27:
  747.         MP_RetCode = 1;
  748.         break;
  749.     }
  750. }
  751.  
  752. BOOL MPEL_OkKeyPressed( void )
  753. {
  754.     MP_RetCode =  -1;
  755. }
  756.  
  757. BOOL MPEL_OkClicked( void )
  758. {
  759.     MP_RetCode = -1;
  760. }
  761.  
  762. BOOL MPEL_AnnullaKeyPressed( void )
  763. {
  764.     MP_RetCode = 1;
  765. }
  766.  
  767. BOOL MPEL_AnnullaClicked( void )
  768. {
  769.     MP_RetCode = 1;
  770. }
  771.  
  772. BOOL MPEL_VersClicked( void )
  773. {
  774. }
  775.  
  776. BOOL MPEL_LibClicked( void )
  777. {
  778.     ActivateGadget( MPEdLibGadgets[ GD_MPEL_Base ], MPEdLibWnd, NULL );
  779. }
  780.  
  781. BOOL MPEL_BaseClicked( void )
  782. {
  783.     ActivateGadget( MPEdLibGadgets[ GD_MPEL_Vers ], MPEdLibWnd, NULL );
  784. }
  785.  
  786. BOOL MPEL_FailKeyPressed( void )
  787. {
  788.     CheckedTag[1] = ( MP_BackLib->lbn_Node.ln_Pri & L_FAIL ) ? FALSE : TRUE;
  789.     GT_SetGadgetAttrsA( MPEdLibGadgets[ GD_MPEL_Fail ], MPEdLibWnd,
  790.             NULL, (struct TagItem *)CheckedTag );
  791.  
  792.     MPEL_FailClicked();
  793. }
  794.  
  795. BOOL MPEL_FailClicked( void )
  796. {
  797.     MP_BackLib->lbn_Node.ln_Pri ^= L_FAIL;
  798. }
  799. ///
  800.  
  801. //      ARexx Editor
  802. /// Libera ARexx Cmds
  803. void LiberaARexxCmds( void )
  804. {
  805.     struct RexxNode *rexx;
  806.  
  807.     while( rexx = RemTail((struct List *)&IE.Rexx_List ))
  808.     FreeObject( rexx, IE_REXXCMD );
  809.  
  810.     IE.NumRexxs = 0;
  811.     NewRexxID = 0;
  812. }
  813. ///
  814. /// ARexx Editor
  815. BOOL RexxEdMenued( void )
  816. {
  817.     BOOL     ret;
  818.  
  819.     if( RexxEdWnd ) {
  820.     ActivateWindow( RexxEdWnd );
  821.     WindowToFront( RexxEdWnd );
  822.     return( TRUE );
  823.     }
  824.  
  825.     LayoutWindow( RexxEdWTags );
  826.     ret = OpenRexxEdWindow();
  827.     PostOpenWindow( RexxEdWTags );
  828.  
  829.     if( ret ) {
  830.     DisplayBeep( Scr );
  831.     CloseRexxEdWindow();
  832.     } else {
  833.  
  834.     if( SysBase->LibNode.lib_Version >= 39 )
  835.         RE_ListTag[0]  = GTLV_MakeVisible;
  836.  
  837.     RE_Last = RE_Timer = 0;
  838.  
  839.     RE_ListTag[1] = RE_ListTag[3] = -1;
  840.  
  841.     AttaccaRexxList();
  842.  
  843.     StringTag[1] = ARexxPortName;
  844.     GT_SetGadgetAttrsA( RexxEdGadgets[ GD_RXE_Port ], RexxEdWnd,
  845.                 NULL, (struct TagItem *)StringTag );
  846.  
  847.     StringTag[1] = RexxExt;
  848.     GT_SetGadgetAttrsA( RexxEdGadgets[ GD_RXE_Ext ], RexxEdWnd,
  849.                 NULL, (struct TagItem *)StringTag );
  850.  
  851.     CycleTag[1] = ( IE.SrcFlags & AREXX_CMD_LIST ) ? 1 : 0;
  852.     GT_SetGadgetAttrsA( RexxEdGadgets[ GD_RXE_CmdIn ], RexxEdWnd,
  853.                 NULL, (struct TagItem *)CycleTag );
  854.  
  855.     RexxEdWnd->ExtData = HandleRexxEd;
  856.     }
  857.  
  858.     return( TRUE );
  859. }
  860.  
  861. void HandleRexxEd( void )
  862. {
  863.     if(!( HandleRexxEdIDCMP() ))
  864.     CloseRexxEdReq();
  865. }
  866.  
  867. void CloseRexxEdReq( void )
  868. {
  869.     if( RexxEdWnd ) {
  870.  
  871.     strcpy( IE.RexxPortName, GetString( RexxEdGadgets[ GD_RXE_Port ]) );
  872.     strcpy( IE.RexxExt, GetString( RexxEdGadgets[ GD_RXE_Ext ]) );
  873.  
  874.     IE.flags &= ~SALVATO;
  875.  
  876.     CloseRexxEdWindow();
  877.     }
  878. }
  879.  
  880. void StaccaRexxList( void )
  881. {
  882.     ListTag[1] = NULL;
  883.     GT_SetGadgetAttrsA( RexxEdGadgets[ GD_RXE_Cmd ], RexxEdWnd,
  884.             NULL, (struct TagItem *)ListTag );
  885. }
  886.  
  887. void AttaccaRexxList( void )
  888. {
  889.     ListTag[1] = &IE.Rexx_List;
  890.     GT_SetGadgetAttrsA( RexxEdGadgets[ GD_RXE_Cmd ], RexxEdWnd,
  891.             NULL, (struct TagItem *)ListTag );
  892.     GT_SetGadgetAttrsA( RexxEdGadgets[ GD_RXE_Cmd ], RexxEdWnd,
  893.             NULL, (struct TagItem *)RE_ListTag );
  894. }
  895.  
  896. BOOL RexxEdIntuiTicks( void )
  897. {
  898.     RE_Timer += 1;
  899.     return( TRUE );
  900. }
  901.  
  902. BOOL RexxEdCloseWindow( void )
  903. {
  904.     return( FALSE );
  905. }
  906.  
  907. BOOL RXE_CmdKeyPressed( void )
  908. {
  909.  
  910.     if( IDCMPMsg.Code & 0x20 ) {
  911.  
  912.     if( RE_ListTag[1] < IE.NumRexxs - 1 )
  913.         RE_ListTag[1] += 1;
  914.     else
  915.         RE_ListTag[1] = 0;
  916.  
  917.     } else {
  918.  
  919.     if( RE_ListTag[1] )
  920.         RE_ListTag[1] -= 1;
  921.     else
  922.         RE_ListTag[1] = IE.NumRexxs - 1;
  923.     }
  924.  
  925.     RE_ListTag[3] = IDCMPMsg.Code = RE_ListTag[1];
  926.  
  927.     GT_SetGadgetAttrsA( RexxEdGadgets[ GD_RXE_Cmd ], RexxEdWnd,
  928.             NULL, (struct TagItem *)RE_ListTag );
  929.  
  930.     return( RXE_CmdClicked() );
  931. }
  932.  
  933. BOOL RXE_CmdClicked( void )
  934. {
  935.     WORD                old = RE_Last;
  936.     struct RexxNode    *rexx;
  937.  
  938.     RE_Last = RE_ListTag[1] = RE_ListTag[3] = IDCMPMsg.Code;
  939.  
  940.     if( RE_Timer < 3 ) {
  941.     if( RE_Last == old ) {
  942.  
  943.         rexx = (struct RexxNode *)&IE.Rexx_List;
  944.         for( old = 0; old <= RE_Last; old++ )
  945.         rexx = rexx->rxn_Node.ln_Succ;
  946.  
  947.         EditRexxCmd( rexx );
  948.     }
  949.     }
  950.  
  951.     RE_Timer = 0;
  952.  
  953.     DisableTag[1] = FALSE;
  954.     GT_SetGadgetAttrsA( RexxEdGadgets[ GD_RXE_Del ], RexxEdWnd,
  955.             NULL, (struct TagItem *)DisableTag );
  956.  
  957.     return( TRUE );
  958. }
  959.  
  960. BOOL RexxEdVanillaKey( void )
  961. {
  962.     if( IDCMPMsg.Code == 27 )
  963.     return( RexxEdCloseWindow() );
  964.  
  965.     return( TRUE );
  966. }
  967.  
  968. BOOL RXE_ExtClicked( void )
  969. {
  970.     return( TRUE );
  971. }
  972.  
  973. BOOL RXE_PortClicked( void )
  974. {
  975.     ActivateGadget( RexxEdGadgets[ GD_RXE_Ext], RexxEdWnd, NULL );
  976.     return( TRUE );
  977. }
  978.  
  979. BOOL RXE_DelKeyPressed( void )
  980. {
  981.     return( RXE_DelClicked() );
  982. }
  983.  
  984. BOOL RXE_DelClicked( void )
  985. {
  986.     struct RexxNode    *rexx;
  987.     int                 old;
  988.  
  989.     rexx = (struct RexxNode *)&IE.Rexx_List;
  990.     for( old = 0; old <= RE_Last; old++ )
  991.     rexx = rexx->rxn_Node.ln_Succ;
  992.  
  993.     StaccaRexxList();
  994.     Remove((struct Node *)rexx );
  995.     AttaccaRexxList();
  996.  
  997.     FreeObject( rexx, IE_REXXCMD );
  998.  
  999.     IE.NumRexxs -= 1;
  1000.  
  1001.     DisableTag[1] = TRUE;
  1002.     GT_SetGadgetAttrsA( RexxEdGadgets[ GD_RXE_Del ], RexxEdWnd,
  1003.             NULL, (struct TagItem *)DisableTag );
  1004.  
  1005.     return( TRUE );
  1006. }
  1007.  
  1008. BOOL RXE_AddKeyPressed( void )
  1009. {
  1010.     return( RXE_AddClicked() );
  1011. }
  1012.  
  1013. BOOL RXE_AddClicked( void )
  1014. {
  1015.     struct RexxNode    *rexx;
  1016.  
  1017.     if( rexx = AllocObject( IE_REXXCMD )) {
  1018.  
  1019.     if( EditRexxCmd( rexx )) {
  1020.  
  1021.         IE.NumRexxs += 1;
  1022.  
  1023.         if(!( rexx->rxn_Label[0] )) {
  1024.         sprintf( rexx->rxn_Label, "Command%03ld", NewRexxID );
  1025.         NewRexxID += 1;
  1026.         }
  1027.  
  1028.         StaccaRexxList();
  1029.         AddTail((struct List *)&IE.Rexx_List, (struct Node *)rexx );
  1030.         AttaccaRexxList();
  1031.  
  1032.     } else {
  1033.         FreeObject( rexx, IE_REXXCMD );
  1034.         Stat( CatCompArray[ MSG_ABORTED ].cca_Str, FALSE, 0 );
  1035.     }
  1036.  
  1037.     } else
  1038.     Stat( CatCompArray[ ERR_NOMEMORY ].cca_Str, TRUE, 0 );
  1039.  
  1040.     return( TRUE );
  1041. }
  1042.  
  1043. BOOL RXE_CmdInKeyPressed( void )
  1044. {
  1045.     CycleTag[1] = ( IE.SrcFlags & AREXX_CMD_LIST ) ? 0 : 1;
  1046.  
  1047.     GT_SetGadgetAttrsA( RexxEdGadgets[ GD_RXE_CmdIn ], RexxEdWnd,
  1048.             NULL, (struct TagItem *)CycleTag );
  1049.  
  1050.     return( RXE_CmdInClicked() );
  1051. }
  1052.  
  1053. BOOL RXE_CmdInClicked( void )
  1054. {
  1055.     IE.SrcFlags ^= AREXX_CMD_LIST;
  1056.  
  1057.     return( TRUE );
  1058. }
  1059. ///
  1060. /// Edit Rexx Cmd
  1061. BOOL EditRexxCmd( struct RexxNode *rexx )
  1062. {
  1063.     int     ret;
  1064.     APTR    Lock;
  1065.  
  1066.     LockAllWindows();
  1067.  
  1068.     Lock = rtLockWindow( RexxEdWnd );
  1069.  
  1070.     LayoutWindow( RexxCmdWTags );
  1071.     ret = OpenRexxCmdWindow();
  1072.     PostOpenWindow( RexxCmdWTags );
  1073.  
  1074.     if( ret ) {
  1075.     DisplayBeep( Scr );
  1076.     ret = FALSE;
  1077.     } else {
  1078.  
  1079.     StringTag[1] = rexx->rxn_Label;
  1080.     GT_SetGadgetAttrsA( RexxCmdGadgets[ GD_RXC_Label ], RexxCmdWnd,
  1081.                 NULL, (struct TagItem *)StringTag );
  1082.  
  1083.     StringTag[1] = rexx->rxn_Name;
  1084.     GT_SetGadgetAttrsA( RexxCmdGadgets[ GD_RXC_Cmd ], RexxCmdWnd,
  1085.                 NULL, (struct TagItem *)StringTag );
  1086.  
  1087.     StringTag[1] = rexx->rxn_Template;
  1088.     GT_SetGadgetAttrsA( RexxCmdGadgets[ GD_RXC_Template ], RexxCmdWnd,
  1089.                 NULL, (struct TagItem *)StringTag );
  1090.  
  1091.     ActivateGadget( RexxCmdGadgets[ GD_RXC_Label ], RexxCmdWnd, NULL );
  1092.  
  1093.     RetCode = 0;
  1094.  
  1095.     do {
  1096.         ReqHandle( RexxCmdWnd, HandleRexxCmdIDCMP );
  1097.     } while(!( RetCode ));
  1098.  
  1099.     if( RetCode > 0 ) {
  1100.         ret = FALSE;
  1101.     } else {
  1102.  
  1103.         StaccaRexxList();
  1104.         strcpy( rexx->rxn_Name, GetString( RexxCmdGadgets[ GD_RXC_Cmd ]) );
  1105.         AttaccaRexxList();
  1106.  
  1107.         STRPTR label;
  1108.  
  1109.         label = GetString( RexxCmdGadgets[ GD_RXC_Label ]);
  1110.  
  1111.         if( label[0] )
  1112.         strcpy( rexx->rxn_Label, label );
  1113.  
  1114.         strcpy( rexx->rxn_Template, GetString( RexxCmdGadgets[ GD_RXC_Template ]) );
  1115.  
  1116.         IE.flags &= ~SALVATO;
  1117.  
  1118.         ret = TRUE;
  1119.     }
  1120.     }
  1121.  
  1122.     CloseRexxCmdWindow();
  1123.  
  1124.     rtUnlockWindow( RexxEdWnd, Lock );
  1125.  
  1126.     UnlockAllWindows();
  1127.  
  1128.     return( ret );
  1129. }
  1130.  
  1131. BOOL RexxCmdVanillaKey( void )
  1132. {
  1133.     switch( RexxCmdMsg.Code ) {
  1134.     case 13:
  1135.         RetCode = -1;
  1136.         break;
  1137.     case 27:
  1138.         RetCode = 1;
  1139.     }
  1140. }
  1141.  
  1142. BOOL RXC_OkKeyPressed( void )
  1143. {
  1144.     STRPTR  cmd;
  1145.  
  1146.     cmd = GetString( RexxCmdGadgets[ GD_RXC_Cmd ]);
  1147.  
  1148.     if( cmd[0] )
  1149.     RetCode = -1;
  1150.     else
  1151.     DisplayBeep( Scr );
  1152. }
  1153.  
  1154. BOOL RXC_AnnullaKeyPressed( void )
  1155. {
  1156.     RetCode = 1;
  1157. }
  1158.  
  1159. BOOL RXC_OkClicked( void )
  1160. {
  1161.     STRPTR  cmd;
  1162.  
  1163.     cmd = GetString( RexxCmdGadgets[ GD_RXC_Cmd ]);
  1164.  
  1165.     if( cmd[0] )
  1166.     RetCode = -1;
  1167.     else
  1168.     DisplayBeep( Scr );
  1169. }
  1170.  
  1171. BOOL RXC_AnnullaClicked( void )
  1172. {
  1173.     RetCode = 1;
  1174. }
  1175.  
  1176. BOOL RXC_TemplateClicked( void )
  1177. {
  1178. }
  1179.  
  1180. BOOL RXC_LabelClicked( void )
  1181. {
  1182.     ActivateGadget( RexxCmdGadgets[ GD_RXC_Cmd ], RexxCmdWnd, NULL );
  1183. }
  1184.  
  1185. BOOL RXC_CmdClicked( void )
  1186. {
  1187.     ActivateGadget( RexxCmdGadgets[ GD_RXC_Template ], RexxCmdWnd, NULL );
  1188. }
  1189. ///
  1190.  
  1191. //      Macros
  1192. /// Tasti funzione
  1193. BOOL MacrosMenued( void )
  1194. {
  1195.     int ret;
  1196.  
  1197.     if( MacroWnd ) {
  1198.     ActivateWindow( MacroWnd );
  1199.     WindowToFront( MacroWnd );
  1200.     return( TRUE );
  1201.     }
  1202.  
  1203.     LayoutWindow( MacroWTags );
  1204.     ret = OpenMacroWindow();
  1205.     PostOpenWindow( MacroWTags );
  1206.  
  1207.     if( ret ) {
  1208.     DisplayBeep( Scr );
  1209.     CloseMacroWindow();
  1210.     } else {
  1211.  
  1212.     F_Offset = 0;
  1213.  
  1214.     SistemaF();
  1215.  
  1216.     MacroWnd->ExtData = HandleMacro;
  1217.     }
  1218.  
  1219.     return( TRUE );
  1220. }
  1221.  
  1222. void HandleMacro( void )
  1223. {
  1224.     if(!( HandleMacroIDCMP() )) {
  1225.     GetF();
  1226.     CloseMacroWindow();
  1227.     }
  1228. }
  1229.  
  1230. BOOL rx_10Clicked( void )
  1231. {
  1232.     return( TRUE );
  1233. }
  1234.  
  1235. BOOL MacroCloseWindow( void )
  1236. {
  1237.     return( FALSE );
  1238. }
  1239.  
  1240. BOOL MacroVanillaKey( void )
  1241. {
  1242.     if(( IDCMPMsg.Code == 13 ) || ( IDCMPMsg.Code == 27 ))
  1243.     return( FALSE );
  1244.  
  1245.     return( TRUE );
  1246. }
  1247.  
  1248. void SistemaF( void )
  1249. {
  1250.     UWORD   cnt, m;
  1251.  
  1252.     m = F_Offset * 10;
  1253.  
  1254.     for( cnt = 0; cnt < 10; cnt++ ) {
  1255.     StringTag[1] = Macros[ m ];
  1256.     m += 1;
  1257.     GT_SetGadgetAttrsA( MacroGadgets[ MacroGads[ cnt ]], MacroWnd,
  1258.                 NULL, (struct TagItem *)StringTag );
  1259.     }
  1260. }
  1261.  
  1262. void GetF( void )
  1263. {
  1264.     int     cnt, m;
  1265.  
  1266.     m = F_Offset * 10;
  1267.  
  1268.     for( cnt = 0; cnt < 10; cnt++ ) {
  1269.     strcpy( &Macros[ m ][0], GetString( MacroGadgets[ MacroGads[ cnt ]]) );
  1270.     m += 1;
  1271.     }
  1272. }
  1273.  
  1274. BOOL QualifClicked( void )
  1275. {
  1276.     GetF();
  1277.  
  1278.     F_Offset = IDCMPMsg.Code;
  1279.  
  1280.     SistemaF();
  1281.  
  1282.     return( TRUE );
  1283. }
  1284.  
  1285. BOOL rx_1Clicked( void )
  1286. {
  1287.     ActivateGadget( MacroGadgets[ GD_rx_2 ], MacroWnd, NULL );
  1288.     return( TRUE );
  1289. }
  1290.  
  1291. BOOL rx_2Clicked( void )
  1292. {
  1293.     ActivateGadget( MacroGadgets[ GD_rx_3 ], MacroWnd, NULL );
  1294.     return( TRUE );
  1295. }
  1296.  
  1297. BOOL rx_3Clicked( void )
  1298. {
  1299.     ActivateGadget( MacroGadgets[ GD_rx_4 ], MacroWnd, NULL );
  1300.     return( TRUE );
  1301. }
  1302.  
  1303. BOOL rx_4Clicked( void )
  1304. {
  1305.     ActivateGadget( MacroGadgets[ GD_rx_5 ], MacroWnd, NULL );
  1306.     return( TRUE );
  1307. }
  1308.  
  1309. BOOL rx_5Clicked( void )
  1310. {
  1311.     ActivateGadget( MacroGadgets[ GD_rx_6 ], MacroWnd, NULL );
  1312.     return( TRUE );
  1313. }
  1314.  
  1315. BOOL rx_6Clicked( void )
  1316. {
  1317.     ActivateGadget( MacroGadgets[ GD_rx_7 ], MacroWnd, NULL );
  1318.     return( TRUE );
  1319. }
  1320.  
  1321. BOOL rx_7Clicked( void )
  1322. {
  1323.     ActivateGadget( MacroGadgets[ GD_rx_8 ], MacroWnd, NULL );
  1324.     return( TRUE );
  1325. }
  1326.  
  1327. BOOL rx_8Clicked( void )
  1328. {
  1329.     ActivateGadget( MacroGadgets[ GD_rx_9 ], MacroWnd, NULL );
  1330.     return( TRUE );
  1331. }
  1332.  
  1333. BOOL rx_9Clicked( void )
  1334. {
  1335.     ActivateGadget( MacroGadgets[ GD_rx_10 ], MacroWnd, NULL );
  1336.     return( TRUE );
  1337. }
  1338.  
  1339. BOOL rx_Get1Clicked( void )
  1340. {
  1341.     rx_GetFile( GD_rx_1 );
  1342.     return( TRUE );
  1343. }
  1344.  
  1345. BOOL rx_Get2Clicked( void )
  1346. {
  1347.     rx_GetFile( GD_rx_2 );
  1348.     return( TRUE );
  1349. }
  1350.  
  1351. BOOL rx_Get3Clicked( void )
  1352. {
  1353.     rx_GetFile( GD_rx_3 );
  1354.     return( TRUE );
  1355. }
  1356.  
  1357. BOOL rx_Get4Clicked( void )
  1358. {
  1359.     rx_GetFile( GD_rx_4 );
  1360.     return( TRUE );
  1361. }
  1362.  
  1363. BOOL rx_Get5Clicked( void )
  1364. {
  1365.     rx_GetFile( GD_rx_5 );
  1366.     return( TRUE );
  1367. }
  1368.  
  1369. BOOL rx_Get6Clicked( void )
  1370. {
  1371.     rx_GetFile( GD_rx_6 );
  1372.     return( TRUE );
  1373. }
  1374.  
  1375. BOOL rx_Get7Clicked( void )
  1376. {
  1377.     rx_GetFile( GD_rx_7 );
  1378.     return( TRUE );
  1379. }
  1380.  
  1381. BOOL rx_Get8Clicked( void )
  1382. {
  1383.     rx_GetFile( GD_rx_8 );
  1384.     return( TRUE );
  1385. }
  1386.  
  1387. BOOL rx_Get9Clicked( void )
  1388. {
  1389.     rx_GetFile( GD_rx_9 );
  1390.     return( TRUE );
  1391. }
  1392.  
  1393. BOOL rx_Get10Clicked( void )
  1394. {
  1395.     rx_GetFile( GD_rx_10 );
  1396.     return( TRUE );
  1397. }
  1398.  
  1399. void rx_GetFile( UWORD gad )
  1400. {
  1401.     if( GetFile3( FALSE, CatCompArray[ ASL_GET_MACRO ].cca_Str, "#?.ie",
  1402.           ASL_GET_MACRO, "ie", ReqFile, ReqDrawer )) {
  1403.  
  1404.     StringTag[1] = allpath;
  1405.     GT_SetGadgetAttrsA( MacroGadgets[ gad ], MacroWnd, NULL, (struct TagItem *)StringTag );
  1406.     }
  1407. }
  1408. ///
  1409. /// Esegui
  1410. BOOL ExecMacroMenued( void )
  1411. {
  1412.     if( GetFile3( FALSE, CatCompArray[ ASL_GET_MACRO ].cca_Str, "#?.ie", ASL_GET_MACRO, "ie", ReqFile, ReqDrawer ))
  1413.     SendRexxMsg( "REXX", "IE", allpath, NULL, 0 );
  1414.  
  1415.     return( TRUE );
  1416. }
  1417. ///
  1418. /// Aggiungi
  1419. BOOL AddMacroMenued( void )
  1420. {
  1421.     if( GetFile3( FALSE, CatCompArray[ ASL_GET_MACRO ].cca_Str, "#?.ie", ASL_GET_MACRO, "ie", ReqFile, ReqDrawer ))
  1422.     AddMacroItem( allpath );
  1423.  
  1424.     return( TRUE );
  1425. }
  1426. ///
  1427. /// Rimuovi
  1428. BOOL RemMacroMenued( void )
  1429. {
  1430.     WORD                num, cnt;
  1431.     struct MacroNode   *mac;
  1432.  
  1433.     if( ApriListaFin( CatCompArray[ ASL_GET_MACRO ].cca_Str, ASL_GET_MACRO, &MacroList )) {
  1434.  
  1435.     num = GestisciListaFin( EXIT, NumMacros );
  1436.     ChiudiListaFin();
  1437.  
  1438.     if( num >= 0 ) {
  1439.  
  1440.         mac = MacroList.mlh_Head;
  1441.         for( cnt = 0; cnt < num; cnt++ )
  1442.         mac = mac->Node.ln_Succ;
  1443.  
  1444.         Remove(( struct Node * )mac );
  1445.  
  1446.         StaccaMenus();
  1447.         RemoveItem( GetMacroMenu(), mac->Menu );
  1448.  
  1449.         mac->Menu->NextItem = NULL;
  1450.         FreeMenus(( struct Menu * )mac->Menu );
  1451.  
  1452.         FreeMem( mac, sizeof( struct MacroNode ));
  1453.  
  1454.         NumMacros -= 1;
  1455.  
  1456.         RemakeMacroMenu();
  1457.     }
  1458.     }
  1459.  
  1460.     return( TRUE );
  1461. }
  1462. ///
  1463. /// ExecMenuMacro
  1464. BOOL ExecMenuMacro( void )
  1465. {
  1466.     struct MenuItem    *item;
  1467.     struct MacroNode   *mac;
  1468.     item = ItemAddress( BackMenus, BackMsg.Code );
  1469.  
  1470.     mac = MacroList.mlh_Head;
  1471.  
  1472.     while( strcmp( mac->Node.ln_Name, ((struct IntuiText *)item->ItemFill)->IText ))
  1473.     mac = mac->Node.ln_Succ;
  1474.  
  1475.     SendRexxMsg( "REXX", "IE", mac->File, NULL, 0 );
  1476. }
  1477. ///
  1478. /// RemakeMacroMenu
  1479. void RemakeMacroMenu( void )
  1480. {
  1481.     struct Menu        *menu;
  1482.  
  1483.     menu = GetMacroMenu();
  1484.  
  1485.     LayoutMenuItems( menu->FirstItem, VisualInfo,
  1486.              GTMN_Menu, menu,
  1487.              GTMN_NewLookMenus, TRUE, TAG_END );
  1488.  
  1489.     AttaccaMenus();
  1490. }
  1491. ///
  1492. /// GetMacroMenu
  1493. struct Menu *GetMacroMenu( void )
  1494. {
  1495.     struct Menu *menu = BackMenus;
  1496.     UWORD        cnt;
  1497.  
  1498.     for( cnt = 0; cnt < 5; cnt++ )
  1499.     menu = menu->NextMenu;
  1500.  
  1501.     return( menu );
  1502. }
  1503. ///
  1504. /// FreeMacroItems
  1505. void FreeMacroItems( void )
  1506. {
  1507.     struct MacroNode *mac;
  1508.  
  1509.     StaccaMenus();
  1510.  
  1511.     while( mac = RemTail(( struct List * )&MacroList )) {
  1512.     RemoveItem( GetMacroMenu(), mac->Menu );
  1513.  
  1514.     mac->Menu->NextItem = NULL;
  1515.     FreeMenus(( struct Menu * )mac->Menu );
  1516.  
  1517.     FreeMem( mac, sizeof( struct MacroNode ));
  1518.     }
  1519.  
  1520.     AttaccaMenus();
  1521. }
  1522. ///
  1523. /// AddMacroItem
  1524. void AddMacroItem( STRPTR File )
  1525. {
  1526.     struct MacroNode   *mac;
  1527.  
  1528.     if( mac = AllocMem( sizeof( struct MacroNode ), MEMF_CLEAR )) {
  1529.  
  1530.     AddTail(( struct List * )&MacroList, ( struct Node * )mac );
  1531.  
  1532.     strcpy( mac->File, File );
  1533.     mac->Node.ln_Name = FilePart( mac->File );
  1534.  
  1535.     struct NewMenu nm[] = { NM_ITEM, mac->Node.ln_Name,
  1536.                 NULL, 0, 0, (APTR)ExecMenuMacro,
  1537.                 NM_END, NULL, NULL, 0, 0, NULL };
  1538.  
  1539.     if( mac->Menu = CreateMenusA( nm, NULL )) {
  1540.         StaccaMenus();
  1541.         AddItem( GetMacroMenu(), mac->Menu );
  1542.         RemakeMacroMenu();
  1543.         NumMacros += 1;
  1544.     } else
  1545.         DisplayBeep( Scr );
  1546.  
  1547.     } else {
  1548.     Stat( CatCompArray[ ERR_NOMEMORY ].cca_Str, TRUE, 0 );
  1549.     }
  1550. }
  1551. ///
  1552. /// SistemaMacroMenu
  1553. void SistemaMacroMenu( void )
  1554. {
  1555.     struct MacroNode   *mac;
  1556.     struct Menu        *menu;
  1557.  
  1558.     menu = GetMacroMenu();
  1559.  
  1560.     StaccaMenus();
  1561.  
  1562.     for( mac = MacroList.mlh_Head; mac->Node.ln_Succ; mac = mac->Node.ln_Succ )
  1563.     AddItem( menu, mac->Menu );
  1564.  
  1565.     RemakeMacroMenu();
  1566. }
  1567. ///
  1568.  
  1569. //      Preferenze
  1570. /// Generatore
  1571. BOOL GenPrefsMenued( void )
  1572. {
  1573.     struct GeneratorNode   *gen;
  1574.     BOOL                    ret;
  1575.  
  1576.     if( GenWnd ) {
  1577.     ActivateWindow( GenWnd );
  1578.     WindowToFront( GenWnd );
  1579.     return( TRUE );
  1580.     }
  1581.  
  1582.     if( GetGenerators() ) {
  1583.  
  1584.     if( GenBase ) {
  1585.  
  1586.         gen = Generators.mlh_Head;
  1587.         Generator = 0;
  1588.         while( gen->GenBase != GenBase ) {
  1589.         gen = gen->Node.ln_Succ;
  1590.         Generator += 1;
  1591.         }
  1592.  
  1593.         CloseLibrary(( struct Library * )GenBase );
  1594.     }
  1595.  
  1596.     LayoutWindow( GenWTags );
  1597.     ret = OpenGenWindow();
  1598.     PostOpenWindow( GenWTags );
  1599.  
  1600.     ListTag[1]  = &Generators;
  1601.     List2Tag[1] = List2Tag[3] = Generator;
  1602.  
  1603.     GT_SetGadgetAttrsA( GenGadgets[ GD_GenList ], GenWnd,
  1604.                 NULL, (struct TagItem *)ListTag );
  1605.     GT_SetGadgetAttrsA( GenGadgets[ GD_GenList ], GenWnd,
  1606.                 NULL, (struct TagItem *)List2Tag );
  1607.  
  1608.     GenWnd->ExtData = HandleGen;
  1609.     }
  1610.  
  1611.     return( TRUE );
  1612. }
  1613.  
  1614. void HandleGen( void )
  1615. {
  1616.     if(!( HandleGenIDCMP() ))
  1617.     CloseGenReq();
  1618. }
  1619.  
  1620. void CloseGenReq( void )
  1621. {
  1622.     if( GenWnd ) {
  1623.  
  1624.        GenBase->Lib.lib_OpenCnt += 1;  // prevent from closing
  1625.  
  1626.     CloseGenWindow();
  1627.     FreeGenerators();
  1628.     }
  1629. }
  1630.  
  1631. BOOL GenCloseWindow( void )
  1632. {
  1633.     return( FALSE );
  1634. }
  1635.  
  1636. BOOL GenConfigKeyPressed( void )
  1637. {
  1638.     return( GenConfigClicked() );
  1639. }
  1640.  
  1641. BOOL GenConfigClicked( void )
  1642. {
  1643.     APTR    Lock;
  1644.  
  1645.     LockAllWindows();
  1646.     Lock = rtLockWindow( GenWnd );
  1647.  
  1648.     Config( &IE );
  1649.  
  1650.     rtUnlockWindow( GenWnd, Lock );
  1651.     UnlockAllWindows();
  1652.  
  1653.     return( TRUE );
  1654. }
  1655.  
  1656. BOOL GenListClicked( void )
  1657. {
  1658.     ULONG                   i;
  1659.     struct GeneratorNode   *gen;
  1660.  
  1661.     Generator = IDCMPMsg.Code;
  1662.  
  1663.     gen = (struct GeneratorNode *)&Generators;
  1664.     for( i = 0; i <= Generator; i++ )
  1665.     gen = gen->Node.ln_Succ;
  1666.  
  1667.     GenBase = gen->GenBase;
  1668.  
  1669.     return( TRUE );
  1670. }
  1671. ///
  1672.  
  1673.  
  1674. //      Varie
  1675. /// GetFile3
  1676. BOOL GetFile3( BOOL savemode, STRPTR titolo, STRPTR pattern, ULONG titn, STRPTR ext,
  1677.            STRPTR File, STRPTR Drawer )
  1678. {
  1679.     UBYTE   *ptr, ch;
  1680.     BOOL     ok = TRUE;
  1681.     struct   FileRequester *req;
  1682.  
  1683.     if(( ext ) && ( ReqFile[0] )) {
  1684.     ptr = ReqFile;
  1685.  
  1686.     do {
  1687.         ch = *ptr++;
  1688.         if(( ch == '.' ) || ( ch == '\0' ))
  1689.         ok = FALSE;
  1690.     } while( ok );
  1691.  
  1692.     if( ch == '\0' ) {
  1693.         ptr -= 1;
  1694.         *ptr++ = '.';
  1695.     }
  1696.  
  1697.     strcpy( ptr, ext );
  1698.     }
  1699.  
  1700.     if( LocaleBase )
  1701.     titolo = GetCatalogStr( Catalog, titn, titolo );
  1702.  
  1703.     if( req = AllocAslRequest( ASL_FileRequest, NULL )) {
  1704.  
  1705.     if ( ok = AslRequestTags( req, ASLFR_DoPatterns,     TRUE,
  1706.                   ASLFR_InitialHeight,  Scr->Height - 40,
  1707.                   ASLFR_TitleText,      titolo,
  1708.                   ASLFR_InitialFile,    File,
  1709.                   ASLFR_InitialDrawer,  Drawer,
  1710.                   ASLFR_InitialPattern, pattern,
  1711.                   ASLFR_Window,         BackWnd,
  1712.                   ASLFR_DoSaveMode,     (ULONG)savemode,
  1713.                   TAG_DONE )) {
  1714.  
  1715.         strcpy( File, req->fr_File );
  1716.         strcpy( Drawer, req->fr_Drawer );
  1717.         strcpy( allpath, req->fr_Drawer );
  1718.         AddPart( allpath, req->fr_File, 1024 );
  1719.     }
  1720.  
  1721.     FreeAslRequest( req );
  1722.  
  1723.     } else {
  1724.     Stat( CatCompArray[ ERR_NOASL ].cca_Str, TRUE, 0 );
  1725.     ok = FALSE;
  1726.     }
  1727.  
  1728.     return( ok );
  1729. }
  1730. ///
  1731. /// RemoveItem
  1732. void RemoveItem( struct Menu *From, struct MenuItem *Item )
  1733. {
  1734.     struct MenuItem *mi, *pred;
  1735.  
  1736.     mi = From->FirstItem;
  1737.     while( mi != Item ) {
  1738.     pred = mi;
  1739.     mi = mi->NextItem;
  1740.     }
  1741.  
  1742.     pred->NextItem = mi->NextItem;
  1743. }
  1744. ///
  1745. /// AddItem
  1746. void AddItem( struct Menu *To, struct MenuItem *Item )
  1747. {
  1748.     struct MenuItem *mi;
  1749.  
  1750.     mi = To->FirstItem;
  1751.  
  1752.     while( mi->NextItem )
  1753.     mi = mi->NextItem;
  1754.  
  1755.     mi->NextItem    = Item;
  1756.     Item->NextItem  = NULL;
  1757. }
  1758. ///
  1759. /// StaccaMenus
  1760. void StaccaMenus( void )
  1761. {
  1762.     struct WindowInfo  *wnd;
  1763.  
  1764.     ClearMenuStrip( BackWnd );
  1765.  
  1766.     if( ToolsWnd )
  1767.     ClearMenuStrip( ToolsWnd );
  1768.  
  1769.     for( wnd = IE.win_list.mlh_Head; wnd->wi_succ; wnd = wnd->wi_succ )
  1770.     if( wnd->wi_flags1 & W_APERTA )
  1771.         ClearMenuStrip( wnd->wi_winptr );
  1772. }
  1773. ///
  1774. /// AttaccaMenus
  1775. void AttaccaMenus( void )
  1776. {
  1777.     struct WindowInfo  *wnd;
  1778.  
  1779.     SetMenuStrip( BackWnd, BackMenus );
  1780.  
  1781.     if( ToolsWnd )
  1782.     SetMenuStrip( ToolsWnd, BackMenus );
  1783.  
  1784.     for( wnd = IE.win_list.mlh_Head; wnd->wi_succ; wnd = wnd->wi_succ )
  1785.     if( wnd->wi_flags1 & W_APERTA )
  1786.         SetMenuStrip( wnd->wi_winptr, BackMenus );
  1787. }
  1788. ///
  1789.